package com.example.summary.sort;

import com.sun.javafx.scene.control.skin.IntegerFieldSkin;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 划分、递归、快排
 * @author bjh
 *
 */
public class Test {

    /**待排序、划分数组*/
    private int[] array;
    /**数组长度*/
    private int length;

    public Test(int[] array){
        this.array = array;
        this.length = array.length;
    }

    /**
     * 打印元素
     */
    public void printArray(){
        for(int i=0; i<length; i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }


    /**
     * 划分
     * @return 划分的分界点
     */
    public int partition(int left, int right, int pivot){
        //左指针的起点，left-1是由于在后面的循环中，每循环一次左指针都要右移，
        //这样可以确保左指针从左边第一个元素开始，不然是从第二个开始
        int leftpoint = left-1;
        //右指针的起点，right+1是由于后面的循环中，每循环一次右指针都要左移，
        //这样可以确保右指针从最右边开始，不然是从倒数第二个开始
        int rightpoint = right+1;
        while(true){
            //找到左边大于pivot的数据，或者走到了最右边仍然没有找到比pivot大的数据
            while(leftpoint<right && array[++leftpoint]<pivot);
            //找到右边小于pivot的数据，或者走到了最左边仍然没有找到比pivot小的数据
            while(rightpoint>left && array[--rightpoint]>pivot);
            //左指针和右指针重叠或相交
            if(leftpoint >= rightpoint){
                break;
            }else{
                //交换左边大的和右边小的数据
                swap(leftpoint,rightpoint);
            }
        }
        //返回分界点，即右边子数组中最左边的点
        return leftpoint;
    }


    /**
     * 交换数据
     */
    public void swap(int leftpoint,int rightpoint){
        int temp = array[leftpoint];
        array[leftpoint] = array[rightpoint];
        array[rightpoint] = temp;
    }

    public static void main(String args[]){
        System.out.println(test(Arrays.asList(1,2,5,6,9,11,12,13)));
//        int a;
//        System.out.println(a=1);
//
//        int[] array = {99,78,26,17,82,36,9,81,22,100,30,20,17,85};
//        Test qs = new Test(array);
//        System.out.println("划分前的数据为：");
//        qs.printArray();
//        int bound = qs.partition(0, array.length-1, 50);
//        System.out.println("划分后的数据为：");
//        qs.printArray();
//        System.out.println("划分的分界点为：" + array[bound] + "，分界点的坐标为：" + bound);
//
//
//        //ab zx 常量池没有，str1.intern()链接str1的引用，所有返回true,重点在于，toString,是char[]，不会生成abzx的字符串
//        String str1 = new StringBuilder("ab").append("zx").toString();
//        System.out.println(str1.intern() == str1);
//        //java 常量池固定，str2.intern()返回常量池字符串，字符串和对象比较返回false
//        String str2 = new StringBuilder("ja").append("va").toString();
//        System.out.println(str2.intern() == str2);
//        //同1
//        String str3 = new StringBuilder("abcdefg").append("asdasdwaeaweawe").toString();
//        System.out.println(str3.intern() == str3);
//        //eeeeeeeeeeeeeeeeeeee字符串在常量池，str2.intern()返回常量池字符串，都是常量字符串比较返回true
//        String str4 = "eeeeeeeeeeeeeeeeeeee";
//        System.out.println(str4.intern() == str4);
//        //创建str5对象，生产两个对象asddweqefsgfrgrga，new String("asddweqefsgfrgrga")，str5。intern
//        //返回字符串常量，和对象比较，所以false
//        String str5 = new String("asddweqefsgfrgrga");
//        System.out.println(str5.intern() == str5);
//        /**
//         * String str6 = new String("abc");
//         str6 = str6 + "123";这个方法会转成第一种情况，所以返回true
//         */
//        String str6 = new String("abc");
//        str6 = str6 + "123";
//        System.out.println(str6.intern() == str6);

    }

    public static List<List<Integer>> test(List<Integer> integers){

        List<List<Integer>> result = new ArrayList<>();
        Stack<Integer> stack = new Stack<>();

        for (int i = 0; i < integers.size()+1; i++) {

            if (!stack.empty()){
                if (i == integers.size() || integers.get(i) - stack.peek()>1){
                    List<Integer> temp = new ArrayList<>();

                    while (!stack.empty()){
                        temp.add(stack.pop());
                    }

                   result.add(temp);
                }
            }

            if (i <integers.size()) {
                stack.push(integers.get(i));
            }

        }

        return result;
    }
}